package com.aaa.vegetablemarketexpress.controller;

import com.aaa.vegetablemarketexpress.entity.Cold;
import com.aaa.vegetablemarketexpress.service.ColdService;
import com.aaa.vegetablemarketexpress.util.Page;
import com.aaa.vegetablemarketexpress.util.Result;
import com.aaa.vegetablemarketexpress.util.ResultUtil;
import com.github.pagehelper.PageInfo;
import lombok.extern.log4j.Log4j2;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.List;

/**
 * @FileName: ColdController
 * @Description: 冷藏方式控制器
 * @Author:
 * @CreateTime: 2025/9/9
 * @Version: 1.0.0
 */
@RestController
@RequestMapping("/cold")
@Log4j2
public class ColdController {

    @Resource
    private ColdService coldService;

    /**
     * 获取冷藏方式列表
     */
    @PostMapping("/list")
    public Result list(@RequestBody Cold cold) {
        log.info("开始查询冷藏方式列表");
        List<Cold> list = coldService.selectColdList(cold);
        log.info("查询冷藏方式列表结束，共查询到{}条记录", list.size());
        return ResultUtil.success(list);
    }

    /**
     * 分页获取冷藏方式列表
     */
    @PostMapping("/listByPage")
    public Result listByPage(@RequestBody Page<Cold> page) {
        log.info("开始执行冷藏方式分页查询");
        Integer pageNo = page.getPageNo();
        Integer pageSize = page.getPageSize();

        if (pageNo == null || pageSize == null || pageNo <= 0 || pageSize <= 0) {
            return ResultUtil.failed("分页参数不正确");
        }

        com.github.pagehelper.PageHelper.startPage(pageNo, pageSize);
        List<Cold> list = coldService.selectColdList(page.getData());
        PageInfo<Cold> pageInfo = new PageInfo<>(list);
        log.info("冷藏方式分页查询结束，共查询到{}条记录", pageInfo.getTotal());
        return ResultUtil.success(pageInfo);
    }

    /**
     * 获取所有正常状态的冷藏方式（用于下拉选择）
     */
    @GetMapping("/listAllNormal")
    public Result listAllNormal() {
        log.info("开始查询所有正常状态的冷藏方式");
        List<Cold> list = coldService.selectAllNormalCold();
        log.info("查询所有正常状态的冷藏方式结束，共查询到{}条记录", list.size());
        return ResultUtil.success(list);
    }

    /**
     * 统计冷藏方式数量
     */
    @PostMapping("/count")
    public Result count(@RequestBody Cold cold) {
        log.info("开始统计冷藏方式数量");
        int count = coldService.countCold(cold);
        log.info("统计冷藏方式数量结束，统计结果为{}", count);
        return ResultUtil.success(count);
    }

    /**
     * 获取冷藏方式详细信息
     */
    @GetMapping("/{coldId}")
    public Result getInfo(@PathVariable("coldId") Long coldId) {
        log.info("开始查询冷藏方式详细信息，冷藏方式ID: {}", coldId);
        Cold cold = coldService.selectColdById(coldId);
        if (cold == null) {
            log.warn("未找到ID为{}的冷藏方式信息", coldId);
            return ResultUtil.failed("未找到对应的冷藏方式信息");
        }
        log.info("查询冷藏方式详细信息结束");
        return ResultUtil.success(cold);
    }

    /**
     * 新增冷藏方式
     */
    @PostMapping("add")
    public Result add(@RequestBody Cold cold) {
        log.info("开始新增冷藏方式，冷藏方式名称: {}", cold.getColdName());
        try {
            int result = coldService.insertCold(cold);
            if (result > 0) {
                log.info("新增冷藏方式成功，冷藏方式ID: {}", cold.getColdId());
                return ResultUtil.success("新增冷藏方式成功");
            } else {
                log.warn("新增冷藏方式失败");
                return ResultUtil.failed("新增冷藏方式失败");
            }
        } catch (Exception e) {
            log.error("新增冷藏方式时发生异常", e);
            return ResultUtil.failed("新增冷藏方式失败: " + e.getMessage());
        }
    }

    /**
     * 修改冷藏方式
     */
    @PostMapping("edit")
    public Result edit(@RequestBody Cold cold) {
        log.info("开始修改冷藏方式，冷藏方式ID: {}", cold.getColdId());
        if (cold.getColdId() == null) {
            return ResultUtil.failed("冷藏方式ID不能为空");
        }
        try {
            int result = coldService.updateCold(cold);
            if (result > 0) {
                log.info("修改冷藏方式成功，冷藏方式ID: {}", cold.getColdId());
                return ResultUtil.success("修改冷藏方式成功");
            } else {
                log.warn("修改冷藏方式失败");
                return ResultUtil.failed("修改冷藏方式失败");
            }
        } catch (Exception e) {
            log.error("修改冷藏方式时发生异常", e);
            return ResultUtil.failed("修改冷藏方式失败: " + e.getMessage());
        }
    }

    /**
     * 删除冷藏方式
     */
    @DeleteMapping("/{coldId}")
    public Result remove(@PathVariable Long coldId) {
        log.info("开始删除冷藏方式，冷藏方式ID: {}", coldId);
        if (coldId == null) {
            return ResultUtil.failed("冷藏方式ID不能为空");
        }
        try {
            int result = coldService.deleteColdById(coldId);
            if (result > 0) {
                log.info("删除冷藏方式成功，冷藏方式ID: {}", coldId);
                return ResultUtil.success("删除冷藏方式成功");
            } else {
                log.warn("删除冷藏方式失败");
                return ResultUtil.failed("删除冷藏方式失败");
            }
        } catch (Exception e) {
            log.error("删除冷藏方式时发生异常", e);
            return ResultUtil.failed("删除冷藏方式失败: " + e.getMessage());
        }
    }

    /**
     * 批量删除冷藏方式
     */
    @DeleteMapping("/batch/{coldIds}")
    public Result removeBatch(@PathVariable Long[] coldIds) {
        log.info("开始批量删除冷藏方式，冷藏方式IDs: {}", (Object) coldIds);
        if (coldIds == null || coldIds.length == 0) {
            return ResultUtil.failed("请选择要删除的冷藏方式");
        }
        try {
            int result = coldService.deleteColdByIds(coldIds);
            if (result > 0) {
                log.info("批量删除冷藏方式成功，删除数量: {}", result);
                return ResultUtil.success("批量删除冷藏方式成功");
            } else {
                log.warn("批量删除冷藏方式失败");
                return ResultUtil.failed("批量删除冷藏方式失败");
            }
        } catch (Exception e) {
            log.error("批量删除冷藏方式时发生异常", e);
            return ResultUtil.failed("批量删除冷藏方式失败: " + e.getMessage());
        }
    }

    /**
     * 校验冷藏方式名称是否唯一
     */
    @GetMapping("/checkColdNameUnique")
    public Result checkColdNameUnique(@RequestBody Cold cold) {
        log.info("开始校验冷藏方式名称唯一性，冷藏方式名称: {}", cold.getColdName());
        String result = coldService.checkColdNameUnique(cold);
        log.info("校验冷藏方式名称唯一性结束，结果: {}", result);
        return ResultUtil.success(result);
    }

    /**
     * 更新冷藏方式状态
     */
    @PutMapping("/changeStatus")
    public Result changeStatus(@RequestBody Cold cold) {
        log.info("开始更新冷藏方式状态，冷藏方式ID: {}, 状态: {}", cold.getColdId(), cold.getStatus());
        if (cold.getColdId() == null) {
            return ResultUtil.failed("冷藏方式ID不能为空");
        }
        try {
            int result = coldService.updateColdStatus(cold.getColdId(), String.valueOf(cold.getStatus()));
            if (result > 0) {
                log.info("更新冷藏方式状态成功，冷藏方式ID: {}", cold.getColdId());
                return ResultUtil.success("更新冷藏方式状态成功");
            } else {
                log.warn("更新冷藏方式状态失败");
                return ResultUtil.failed("更新冷藏方式状态失败");
            }
        } catch (Exception e) {
            log.error("更新冷藏方式状态时发生异常", e);
            return ResultUtil.failed("更新冷藏方式状态失败: " + e.getMessage());
        }
    }
}
